{
  // Buffer.alloc(size[, fill[, encoding]])
  // 长度为 10、且用 0 填充的 Buffer。
  const buf1 = Buffer.alloc(10);
  console.log(buf1);
  // 长度为 10、且用 0x1 填充的 Buffer
  const buf2 = Buffer.alloc(10, 1);
  console.log(buf2);
}

{
  // Buffer.allocUnsafe(size)
  // 长度为 10 的 Buffer。它不会被初始化，所以它可能包含旧数据。
  const buf = Buffer.allocUnsafe(10);
  console.log(buf);
}

{
  // Buffer.allocUnsafeSlow(size)
  // 长度为 10 的 Buffer。它不会被初始化，所以它可能包含旧数据。
  const buf = Buffer.allocUnsafeSlow(10);
  console.log(buf);

  // Buffer.allocUnsafe() 与 Buffer.allocUnsafeSlow() 异同点。
  // - Buffer.allocUnsafe 是从内存池中分配一部分内存使用，而 Buffer.allocUnsafeSlow 是操作系统直接分配内存的。
  // - 2 种方式都不会初始化，因此有可能会存在旧数据
  // - allocUnsafe 更快更高效，而 allocUnsafeSlow 更慢

  // Tips
  // 1. 系统调用开销：从操作系统直接分配内存需要进行系统调用，而系统调用相对于用户态的操作开销更大。每次系统调用都需要从用户态切换到内核态，这个过程需要保存当前用户态的上下文，然后切换到内核态，执行内核态代码，最后再切换回用户态。因此，频繁的系统调用会影响程序的性能。
  // 2. 内存管理复杂性：操作系统直接分配内存，需要进行内存管理，包括内存的分配、释放等。而内存池管理则是由 Node.js 自己管理，更加灵活。
  // 3. 内存池优化：内存池通过预先分配一大块内存并在用户态进行管理，避免了频繁的系统调用和复杂的内存管理操作，从而提高了内存分配的效率。
}

{
  // Buffer.from(array)
  // array 的元素只能是数字，不然就会自动被 0 覆盖
  const buf = Buffer.from([0b10000000, 0o200, 128, 0x80]);
  console.log(buf);
}

{
  // Buffer.from(arrayBuffer[, byteOffset[, length]])
  // 返回一个 ArrayBuffer 共享内存的 Buffer。
  const arrayBuffer = new ArrayBuffer(8);
  const view = new Uint8Array(arrayBuffer);
  view[0] = 0x80; // 设置第一个字节为 0x80
  view[1] = 0x81; // 设置第二个字节为 0x81
  view[2] = 0x82; // 设置第三个字节为 0x82
  view[3] = 0x83; // 设置第四个字节为 0x83
  // 从 ArrayBuffer 创建 Buffer
  const buf1 = Buffer.from(arrayBuffer);
  console.log(buf1); // 输出: <Buffer 80 81 82 83 00 00 00 00>

  // 从 ArrayBuffer 的偏移量 1 开始创建 Buffer
  const buf2 = Buffer.from(arrayBuffer, 1);
  console.log(buf2); // 输出: <Buffer 81 82 83 00 00 00 00>

  // 从 ArrayBuffer 的偏移量 1 开始，长度为 2 的部分创建 Buffer
  const buf3 = Buffer.from(arrayBuffer, 1, 2);
  console.log(buf3); // 输出: <Buffer 81 82>
}

{
  // Buffer.from(buffer)
  // 复制 buffer 的数据到新建的 Buffer 实例。
  const buf = Buffer.alloc(8);
  console.log(Buffer.from(buf));
}

{
  // Buffer.from(string[, encoding])
  // string 的值初始化 Buffer
  const buf = Buffer.from("runoob", "ascii");

  console.log(buf);

  console.log(buf.toString("hex"));

  console.log(buf.toString("base64"));
}

{
  // buf.write(string[, offset[, length]][, encoding])
  // 写入缓冲区
  const buf = Buffer.alloc(24);
  const len = buf.write("今天的天气", 2, 15, "utf8");
  console.log(buf, len);

  // buf.toString([encoding[, start[, end]]])
  // 从缓冲区读取数据
  console.log(buf.toString("utf8", 3, 11));

  // buf.toJSON()
  // 转成 JSON 对象
  console.log(buf.toJSON());

  // Buffer.concat(list[, totalLength])
  // 缓冲区合并
  const buf1 = Buffer.from("今天的天气");
  const buf2 = Buffer.from("明天的");
  const buf3 = Buffer.concat([buf1, buf2]);
  console.log(buf3.toString());

  // buf.compare(otherBuffer)
  // 缓冲区比较。逐字节比较大小
  const res = buf1.compare(buf2);
  console.log(res);
  if (res < 0) {
    console.log("buf1 在 buf2 之前");
  } else if (res > 0) {
    console.log("buf1 在 buf2 之后");
  } else {
    console.log("相同");
  }

  // buf.copy(targetBuffer[, targetStart[, sourceStart[, sourceEnd]]])
  // 拷贝缓冲区
  const buf4 = Buffer.from("abcdefg");
  const buf5 = Buffer.from("iiii");
  buf5.copy(buf4, 2);
  console.log(buf4.toString());

  // buf.subarray([start[, end]])
  // 缓冲区裁剪
  console.log(buf4.subarray(2, 5).toString());
}
